package com.ry.day1129;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class LC87 {

      static class TreeNode {
          public int val;
          public TreeNode left, right;
          public TreeNode(int val) {
              this.val = val;
              this.left = this.right = null;
          }
      }


    static class Solution {
        /**
         * @param root: The root of the binary search tree.
         * @param value: Remove the node with given value.
         * @return: The root of the binary search tree after removal.
         */
        public TreeNode removeNode(TreeNode root, int value) {
            /*
            思路：
            首先处理根节点为空的情况，直接返回 null 。
            如果要删除的值小于根节点值，在左子树中递归删除，并返回根节点。
            如果要删除的值大于根节点值，在右子树中递归删除，并返回根节点。
            如果根节点值等于要删除的值：
            如果左右子树都为空，直接返回 null 。
            如果右子树为空，返回左子树。
            如果左子树为空，返回右子树。
            如果左右子树都不为空，找到右子树中的最小节点（即后继节点），将其值赋给根节点，然后在右子树中删除该后继节点，最后返回根节点。
            代码分析：

            在 deleteNode 方法中，通过一系列的条件判断来确定要执行的删除操作。
            对于不同大小关系的比较，决定在左子树或右子树中递归。
            在处理删除节点时，根据子树的情况进行不同的处理。
             */
            Map<TreeNode,TreeNode> parents = new HashMap<>();
            TreeNode[] delarr = getNode(root,value,parents);
            TreeNode delnode = delarr[0];
            TreeNode delparent = delarr[1];

            return null;
        }

        //result: 0->要删除的节点   1->删除节点的父节点
        public  TreeNode[] getNode(TreeNode root,int target, Map<TreeNode,TreeNode> parents){
            if(root ==null) return null;
            Queue<TreeNode> q = new LinkedList<>();
            q.add(root);
            parents.put(root,null);
            while (!q.isEmpty()){
                TreeNode poll= q.poll();
                if(poll.val == target)  {
                    return new TreeNode[]{poll,parents.get(poll)};
                }
                if(poll.left!=null){
                    parents.put(poll.left,poll);
                    q.add(poll.left);
                }
                if(poll.right!=null){
                    parents.put(poll.right,poll);
                    q.add(poll.right);
                }
            }

            return new TreeNode[]{null,null};
        }
    }


    public static void main(String[] args) {
        TreeNode root1 = new TreeNode(5);
        root1.left = new TreeNode(3);
        root1.right = new TreeNode(6);
        root1.left.left= new TreeNode(2);
        root1.left.right = new TreeNode(4);
        root1.right.right = new TreeNode(7);
        TreeNodeShow.show(root1);
    }


    //打印二叉树的类
    // TreeOperation.java
    static class TreeNodeShow {
    /*
    树的结构示例：
              1
            /   \
          2       3
         / \     / \
        4   5   6   7
    */

        // 用于获得树的层数
        public static int getTreeDepth(TreeNode root) {
            return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
        }


        private static void writeArray(TreeNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
            // 保证输入的树不为空
            if (currNode == null) return;
            // 先将当前节点保存到二维数组中
            res[rowIndex][columnIndex] = String.valueOf(currNode.val);

            // 计算当前位于树的第几层
            int currLevel = ((rowIndex + 1) / 2);
            // 若到了最后一层，则返回
            if (currLevel == treeDepth) return;
            // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
            int gap = treeDepth - currLevel - 1;

            // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
            if (currNode.left != null) {
                res[rowIndex + 1][columnIndex - gap] = "/";
                writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
            }

            // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
            if (currNode.right != null) {
                res[rowIndex + 1][columnIndex + gap] = "\\";
                writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
            }
        }


        public static void show(TreeNode root) {
            if (root == null) System.out.println("EMPTY!");
            // 得到树的深度
            int treeDepth = getTreeDepth(root);

            // 最后一行的宽度为2的（n - 1）次方乘3，再加1
            // 作为整个二维数组的宽度
            int arrayHeight = treeDepth * 2 - 1;
            int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
            // 用一个字符串数组来存储每个位置应显示的元素
            String[][] res = new String[arrayHeight][arrayWidth];
            // 对数组进行初始化，默认为一个空格
            for (int i = 0; i < arrayHeight; i++) {
                for (int j = 0; j < arrayWidth; j++) {
                    res[i][j] = " ";
                }
            }

            // 从根节点开始，递归处理整个树
            // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
            writeArray(root, 0, arrayWidth / 2, res, treeDepth);

            // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
            for (String[] line : res) {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < line.length; i++) {
                    sb.append(line[i]);
                    if (line[i].length() > 1 && i <= line.length - 1) {
                        i += line[i].length() > 4 ? 2 : line[i].length() - 1;
                    }
                }
                System.out.println(sb.toString());
            }
        }
    }
}


/*
LintCode-Logo
搜索题目、标签、题集
中文
您上个月的个人报告已生成，点击查看
avatar
87 · 删除二叉查找树的节点
算法
困难
通过率
32%

题目
题解40
笔记
讨论99+
排名
记录
描述
给定一棵具有不同节点值的二叉查找树，删除树中与给定值相同的节点。如果树中没有相同值的节点，就不做任何处理。你应该保证处理之后的树仍是二叉查找树。

最短时间刷“透”算法面试：《66页算法宝典》.pdf

微信添加【jiuzhangfeifei】备注【66】领取


样例
样例 1：

输入：

Tree = {5,3,6,2,4}
value = 3
输出：

{5,2,6,#,4} 或 {5,4,6,2}
解释：

给定了以下二叉搜索树:
    5
   / \
  3   6
 / \
2   4
移去3，你可以返回:
    5
   / \
  2   6
   \
    4
或
    5
   / \
  4   6
 /
2
样例 2：

输入：

Tree = {5,3,6,2,4}
value = 4
输出：

{5,3,6,2}
解释：

给定了以下二叉搜索树:
    5
   / \
  3   6
 / \
2   4
移去4，你应该返回
    5
   / \
  3   6
 /
2
相关知识
学习《2024年7月北美大厂最新面试真题精讲》课程中的4.3Microsoft：最新面试精选002相关内容 ，了解更多相关知识！
标签
相关题目

85
在二叉查找树中插入节点
简单
推荐课程

简历/BQ/项目 面试软技能指导
FLAG高级工程师深度BQ辅导，简历打造+1V1模拟面试，反面试套路、高效上岸！
76/77
已开启智能提示
发起考试
45 分 00 秒
12345678910111213141516171819202122
/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }

控制台
历史提交

 */
